package com.speedata.uhftest;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.serialport.DeviceControlSpd;
import android.serialport.SerialPortSpd;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.speedata.utils.Logcat;

import java.io.IOException;

import androidex.RFIDInterface;
import androidex.SerialHelper;

/**
 * @author xuyan  准备调试军工uhf模块。
 */
public class UhfTestActivity extends AppCompatActivity implements View.OnClickListener {

    private TextView mShowResult;

    private SerialHelper serialHelper;
    private RFIDInterface.RFID_Callbacklistener rfidCallbacklistener;
    private RFIDInterface.CallbackListener callbackListener;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_uhf_test);

        initView();
        //初始化
        initUhf();
    }

    @Override
    protected void onDestroy() {
        powerOff();
        super.onDestroy();
    }

    /**
     * 串口句柄
     */
    private static int fd;

    /**
     * powerOn("EXPAND", 9, 14);
     * port = "/dev/ttyMT0";
     * 115200
     */
    private void initUhf() {

        //上电
        powerOn("EXPAND", 9, 14);
        SerialPortSpd serialPort = new SerialPortSpd();
        try {
            serialPort.OpenSerial("/dev/ttyMT0", 115200);
            fd = serialPort.getFd();
        } catch (IOException e) {
            e.printStackTrace();
        }

        //仿照demo源码，关闭自己串口，用SDK的方式开串口
        serialPort.CloseSerial(fd);

        //盘点数据回调结果
        rfidCallbacklistener = (b, s) -> runOnUiThread(() -> {
            if (b) {
                mShowResult.append(s + "\n");
            } else {
                Logcat.d("rfidCallbacklistener false");
            }
        });

        callbackListener = (b, s) -> runOnUiThread(() -> {
            if (b) {
                mShowResult.append(s + "\n");
            } else {
                Logcat.d("callbackListener false");
            }
        });
    }

    private void initView() {
        Button mOpen = findViewById(R.id.button_open);
        Button mClose = findViewById(R.id.button_close);
        Button mStartRead = findViewById(R.id.button_start);
        Button mStopRead = findViewById(R.id.button_stop);
        Button mClear = findViewById(R.id.button_clear);

        mOpen.setOnClickListener(this);
        mClose.setOnClickListener(this);
        mStartRead.setOnClickListener(this);
        mStopRead.setOnClickListener(this);
        mClear.setOnClickListener(this);

        mShowResult = findViewById(R.id.textView_show_result);
    }


    private void GET_PROTO_MASK() {
        new Thread(() -> {
            try {
                Thread.sleep(500);
                serialHelper.GET_PROTO_MASK(callbackListener);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }

    @SuppressLint("NonConstantResourceId")
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.button_open:
                //初始化接口
                serialHelper = new SerialHelper();
                //设置串口位置路径 例："/dev/ttyS4"
                serialHelper.setPort("/dev/ttyMT0");
                //设置串口波特率
                serialHelper.setBaudRate(115200);
                //打开串口
                try {
                    serialHelper.open();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                GET_PROTO_MASK();

                break;
            case R.id.button_close:
                //关闭串口
                serialHelper.close();

                break;
            case R.id.button_start:
                //开始盘点
                //标签盘点命令 参数形式：16进制字符串
                //  InvType：盘点方式
                // 2：盘点；
                // 其他值：无效；
                //  InvParam：盘点方式对应的参数 0。一直盘点
                serialHelper.GET_PROTO_MASK(callbackListener);

                new Thread(() -> {
                    try {
                        Thread.sleep(100);
                        serialHelper.HSURM_INVENTORYISO_CONTINUE_TIME(2, 0, rfidCallbacklistener);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }).start();

                break;
            case R.id.button_stop:
                //停止盘点
                serialHelper.HSURM_STOP_INVENTORY();
                break;
            case R.id.button_clear:
                mShowResult.setText("");
                break;
            default:
                break;
        }
    }

    /**
     * 其他接口调用，备用。
     */
    private void OtherUhfMethods() {

        //看方法名，应该是保存设置内容
        serialHelper.HSURM_SAVE_SETTING(callbackListener);


        //获取在位天线射频输出功率
        serialHelper.HSURM_Get_ANT_PWR(callbackListener);

        //读取模块信息
        serialHelper.HSURM_GET_INFO(callbackListener);

        //获取链路参数 16进制字符串
        //  String Proto（协议码）:
        // "00"--ISO18000-63;
        // "01"--GB/T29768;
        // "02"--GJB 7377.1;
        // 其他值无效
        serialHelper.HSURM_Get_RF_Prm(0, callbackListener);

        //获取射频工作频率 参数形式：16进制字符串
        //  String Proto（协议码）:
        // "00"--ISO18000-63;
        // "01"--GB/T29768;
        // "02"--GJB 7377.1;
        // 其他值无效
        serialHelper.HSURM_Multi_Get_Fre(0, callbackListener);

        //设置射频工作频率 参数形式：16进制字符串
        //  String Proto（协议码）:
        // "00"--ISO18000-63;
        // "01"--GB/T29768;
        // "02"--GJB 7377.1;
        //  String REGION（地域索引）:
        // 00：CHINA-2；
        // 01：FCC；
        // 02：JAPAN；
        // （暂不支持）03：MALAYSIA；
        // （暂不支持）04：ETSI；
        // 05：CHINA-1；
        // 06：自定义；
        //  String StartFrei（兆赫兹起始频率的整数部分）:
        // 如920.125MHz，STRATFREI =920，高字节=0x3，低字节=0x98；即"0398"
        //  String StartFred（兆赫兹起始频率的整数部分）:
        // 如920.125MHz，STRATFRED =125，高字节=0x0，低字节=0x7D；即"007D"
        //  String StepFre（频率步进KHz）:
        // 如125KHz，STEPFRE =125，高字节=0x4，低字节=0xE2；即"04E2"
        //  String CN（信道数）:
        // 信道数大于1则说明设置模块以"跳频工模式"，信道数等于1则说明设置模块以"定频工作模式"
        serialHelper.HSURM_Multi_Set_Fre(0, 0, "920.125", 125, 1, callbackListener);

        //重启模块
        serialHelper.HSURM_REBOOT(callbackListener);

        //设置在位天线射频输出功率 传入参数形式：16进制字符串
        //  多个功率值：范围：10-51
        // Antn_pwr =(Ant1_pwr，Ant2_pwr,···,Ant(n)_pwr) 用“ ，”隔开。
        serialHelper.HSURM_Set_ANT_PWR(50, callbackListener);

        //读取模块配置的协议掩码 Proto_Mask : NC
        serialHelper.GET_PROTO_MASK(callbackListener);

        //设置模块配置的协议掩码 参数形式：16进制字符串
        //  Option：命令控制选项
        // 0x01：设置； 即"01"
        // 0x02：读取； 即"02"
        // 其他值：无效
        //  Proto_mask：协议掩码，是以下协议掩码值组合而来，取值范围大于0且小于等于7。
        serialHelper.SET_PROTO_MASK(1, 1, callbackListener);

        //设置链路参数 参数形式：16进制字符串
        //  String Proto（协议码）:
        // "00"--ISO18000-63;
        // "01"--GB/T29768;
        // "02"--GJB 7377.1;
        // 其他值无效
        //  Rf_item：链路模式索引
        // "00": 160KHz,FM0，Tari=12.5us
        // "01": 160Khz Miller8，Tari=12.5us
        // "02": 250Khz FM0，Tari=12.5us
        // "03":320Khz Miller4，Tari=6.25us
        // 其他暂不支持
        //  Rsv：预留
        serialHelper.HSURM_Set_RF_Prm(0, 0, callbackListener);

        //发送串口指令（字符串） Hex String数据指令
        serialHelper.sendHex("AAAAAAAA");


    }

    /**
     * 上电对象  上下电
     */
    private static DeviceControlSpd pw;

    private static void powerOn(String powerType, int... gpios) {
        StringBuilder gpiosStr = new StringBuilder();
        for (int gpio : gpios) {
            gpiosStr.append(gpio).append(",");
        }
        try {
            pw = new DeviceControlSpd(powerType, gpios);
            pw.PowerOnDevice();
        } catch (IOException e) {
            e.printStackTrace();
            Log.d("ZM", "powerOn-Exception: " + e.toString());
        }
    }

    private static void powerOff() {
        try {
            pw.PowerOffDevice();
        } catch (IOException e) {
            e.printStackTrace();
            Log.d("ZM", "powerOff-Exception: " + e.toString());
        }
    }
}